home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 June / PersonalComputerWorld-June2009-CoverdiscCD.iso / Software / Freeware / Adobe AIR 1.5.1 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / collections / ModifiedCollectionView.as < prev    next >
Encoding:
Text File  |  2009-02-12  |  26.2 KB  |  855 lines
  1. package mx.collections
  2. {
  3.    import flash.events.Event;
  4.    import flash.utils.Dictionary;
  5.    import mx.collections.errors.CollectionViewError;
  6.    import mx.core.mx_internal;
  7.    import mx.events.CollectionEvent;
  8.    import mx.events.CollectionEventKind;
  9.    import mx.events.PropertyChangeEvent;
  10.    import mx.resources.IResourceManager;
  11.    import mx.resources.ResourceManager;
  12.    
  13.    use namespace mx_internal;
  14.    
  15.    public class ModifiedCollectionView implements ICollectionView
  16.    {
  17.       mx_internal static const VERSION:String = "3.0.0.0";
  18.       
  19.       public static const REMOVED:String = "removed";
  20.       
  21.       public static const ADDED:String = "added";
  22.       
  23.       public static const REPLACED:String = "replaced";
  24.       
  25.       public static const REPLACEMENT:String = "replacement";
  26.       
  27.       private var addedItems:Dictionary;
  28.       
  29.       private var _showPreserved:Boolean = false;
  30.       
  31.       private var list:ICollectionView;
  32.       
  33.       private var deltaLength:int = 0;
  34.       
  35.       private var resourceManager:IResourceManager;
  36.       
  37.       private var removedItems:Dictionary;
  38.       
  39.       private var itemWrappersByIndex:Array;
  40.       
  41.       private var replacementItems:Dictionary;
  42.       
  43.       private var deltas:Array;
  44.       
  45.       private var replacedItems:Dictionary;
  46.       
  47.       private var itemWrappersByCollectionMod:Dictionary;
  48.       
  49.       public function ModifiedCollectionView(param1:ICollectionView)
  50.       {
  51.          resourceManager = ResourceManager.getInstance();
  52.          deltas = [];
  53.          removedItems = new Dictionary(true);
  54.          addedItems = new Dictionary(true);
  55.          replacedItems = new Dictionary(true);
  56.          replacementItems = new Dictionary(true);
  57.          itemWrappersByIndex = [];
  58.          itemWrappersByCollectionMod = new Dictionary(true);
  59.          super();
  60.          this.list = param1;
  61.       }
  62.       
  63.       mx_internal function getBookmarkIndex(param1:CursorBookmark) : int
  64.       {
  65.          var _loc3_:String = null;
  66.          if(!(param1 is ModifiedCollectionViewBookmark) || ModifiedCollectionViewBookmark(param1).mx_internal::view != this)
  67.          {
  68.             _loc3_ = resourceManager.getString("collections","bookmarkNotFound");
  69.             throw new CollectionViewError(_loc3_);
  70.          }
  71.          var _loc2_:ModifiedCollectionViewBookmark = ModifiedCollectionViewBookmark(param1);
  72.          return _loc2_.mx_internal::index;
  73.       }
  74.       
  75.       public function willTrigger(param1:String) : Boolean
  76.       {
  77.          return false;
  78.       }
  79.       
  80.       private function removeModification(param1:CollectionModification) : Boolean
  81.       {
  82.          var _loc2_:int = 0;
  83.          while(_loc2_ < deltas.length)
  84.          {
  85.             if(deltas[_loc2_] == param1)
  86.             {
  87.                deltas.splice(_loc2_,1);
  88.                return true;
  89.             }
  90.             _loc2_++;
  91.          }
  92.          return false;
  93.       }
  94.       
  95.       mx_internal function getWrappedItemUsingCursor(param1:ModifiedCollectionViewCursor, param2:int) : Object
  96.       {
  97.          var _loc6_:CollectionModification = null;
  98.          var _loc9_:Object = null;
  99.          var _loc3_:int = param2;
  100.          var _loc4_:Object = null;
  101.          var _loc5_:CollectionModification = null;
  102.          var _loc7_:Boolean = false;
  103.          var _loc8_:int = 0;
  104.          while(_loc8_ < deltas.length)
  105.          {
  106.             _loc6_ = deltas[_loc8_];
  107.             if(_loc3_ < _loc6_.index)
  108.             {
  109.                break;
  110.             }
  111.             if(_loc6_.modificationType == CollectionModification.REPLACE)
  112.             {
  113.                if(_loc3_ == _loc6_.index && _loc6_.showOldReplace && _showPreserved)
  114.                {
  115.                   _loc5_ = _loc6_;
  116.                   break;
  117.                }
  118.                if(_loc3_ == _loc6_.index + 1 && _loc6_.showOldReplace && _loc6_.showNewReplace && _showPreserved)
  119.                {
  120.                   _loc3_--;
  121.                   _loc7_ = true;
  122.                   break;
  123.                }
  124.                if(_loc3_ == _loc6_.index && (!_loc6_.showOldReplace && _loc6_.showNewReplace || !_showPreserved))
  125.                {
  126.                   _loc7_ = true;
  127.                   break;
  128.                }
  129.                _loc3_ -= _loc6_.modCount;
  130.             }
  131.             else if(isActive(_loc6_))
  132.             {
  133.                if(_loc3_ == _loc6_.index && _loc6_.isRemove)
  134.                {
  135.                   _loc5_ = _loc6_;
  136.                   break;
  137.                }
  138.                if(_loc3_ >= _loc6_.index)
  139.                {
  140.                   _loc3_ -= _loc6_.modCount;
  141.                }
  142.             }
  143.             _loc8_++;
  144.          }
  145.          if(_loc5_)
  146.          {
  147.             _loc4_ = _loc5_.item;
  148.          }
  149.          else
  150.          {
  151.             param1.internalCursor.seek(CursorBookmark.CURRENT,_loc3_ - param1.internalIndex);
  152.             _loc4_ = param1.internalCursor.current;
  153.             param1.internalIndex = _loc3_;
  154.          }
  155.          if(_loc6_ && _loc3_ == _loc6_.index && _loc6_.modificationType == CollectionModification.ADD)
  156.          {
  157.             _loc9_ = getUniqueItemWrapper(_loc4_,_loc6_,_loc3_);
  158.          }
  159.          else
  160.          {
  161.             _loc9_ = getUniqueItemWrapper(_loc4_,_loc5_,_loc3_);
  162.          }
  163.          return _loc9_;
  164.       }
  165.       
  166.       public function contains(param1:Object) : Boolean
  167.       {
  168.          return false;
  169.       }
  170.       
  171.       private function integrateReplacedElements(param1:CollectionEvent, param2:int, param3:int) : void
  172.       {
  173.          var _loc9_:Object = null;
  174.          var _loc10_:Object = null;
  175.          var _loc11_:CollectionModification = null;
  176.          var _loc12_:CollectionModification = null;
  177.          var _loc4_:int = 0;
  178.          var _loc5_:int = 0;
  179.          var _loc6_:Boolean = false;
  180.          var _loc7_:int = int(param1.items.length);
  181.          var _loc8_:int = 0;
  182.          while(_loc4_ < deltas.length && _loc5_ < _loc7_)
  183.          {
  184.             _loc9_ = PropertyChangeEvent(param1.items[_loc5_]).oldValue;
  185.             _loc10_ = PropertyChangeEvent(param1.items[_loc5_]).newValue;
  186.             _loc11_ = CollectionModification(deltas[_loc4_]);
  187.             _loc12_ = new CollectionModification(param1.location + _loc5_,_loc9_,CollectionModification.REPLACE);
  188.             if(_loc11_.isRemove && _loc11_.index <= _loc12_.index || !_loc11_.isRemove && _loc11_.index < _loc12_.index)
  189.             {
  190.                _loc4_++;
  191.             }
  192.             else if((_loc11_.modificationType == CollectionModification.ADD || _loc11_.modificationType == CollectionModification.REPLACE) && _loc11_.index == _loc12_.index)
  193.             {
  194.                _loc4_++;
  195.                _loc5_++;
  196.             }
  197.             else
  198.             {
  199.                deltas.splice(_loc4_ + _loc5_,0,_loc12_);
  200.                replacedItems[getUniqueItemWrapper(_loc9_,_loc12_,param1.location + _loc5_)] = _loc12_;
  201.                replacementItems[getUniqueItemWrapper(_loc10_,_loc12_,param1.location + _loc5_,true)] = _loc12_;
  202.                _loc5_++;
  203.                _loc4_++;
  204.             }
  205.          }
  206.          while(_loc5_ < _loc7_)
  207.          {
  208.             _loc9_ = PropertyChangeEvent(param1.items[_loc5_]).oldValue;
  209.             _loc10_ = PropertyChangeEvent(param1.items[_loc5_]).newValue;
  210.             deltas.push(_loc12_ = new CollectionModification(param1.location + _loc5_,_loc9_,CollectionModification.REPLACE));
  211.             replacedItems[getUniqueItemWrapper(_loc9_,_loc12_,param1.location + _loc5_)] = _loc12_;
  212.             replacementItems[getUniqueItemWrapper(_loc10_,_loc12_,param1.location + _loc5_,true)] = _loc12_;
  213.             _loc5_++;
  214.          }
  215.       }
  216.       
  217.       mx_internal function getBookmark(param1:ModifiedCollectionViewCursor) : ModifiedCollectionViewBookmark
  218.       {
  219.          var _loc4_:String = null;
  220.          var _loc2_:int = param1.mx_internal::currentIndex;
  221.          if(_loc2_ < 0 || _loc2_ > length)
  222.          {
  223.             _loc4_ = resourceManager.getString("collections","invalidIndex",[_loc2_]);
  224.             throw new CollectionViewError(_loc4_);
  225.          }
  226.          var _loc3_:Object = param1.current;
  227.          return new ModifiedCollectionViewBookmark(_loc3_,this,0,_loc2_,param1.internalCursor.bookmark,param1.internalIndex);
  228.       }
  229.       
  230.       public function get sort() : Sort
  231.       {
  232.          return null;
  233.       }
  234.       
  235.       public function itemUpdated(param1:Object, param2:Object = null, param3:Object = null, param4:Object = null) : void
  236.       {
  237.       }
  238.       
  239.       public function processCollectionEvent(param1:CollectionEvent, param2:int, param3:int) : void
  240.       {
  241.          switch(param1.kind)
  242.          {
  243.             case CollectionEventKind.ADD:
  244.                integrateAddedElements(param1,param2,param3);
  245.                break;
  246.             case CollectionEventKind.REMOVE:
  247.                integrateRemovedElements(param1,param2,param3);
  248.                break;
  249.             case CollectionEventKind.REPLACE:
  250.                integrateReplacedElements(param1,param2,param3);
  251.          }
  252.       }
  253.       
  254.       public function get showPreservedState() : Boolean
  255.       {
  256.          return _showPreserved;
  257.       }
  258.       
  259.       public function getSemantics(param1:ItemWrapper) : String
  260.       {
  261.          if(removedItems[param1])
  262.          {
  263.             return ModifiedCollectionView.REMOVED;
  264.          }
  265.          if(addedItems[param1])
  266.          {
  267.             return ModifiedCollectionView.ADDED;
  268.          }
  269.          if(replacedItems[param1])
  270.          {
  271.             return ModifiedCollectionView.REPLACED;
  272.          }
  273.          if(replacementItems[param1])
  274.          {
  275.             return ModifiedCollectionView.REPLACEMENT;
  276.          }
  277.          return null;
  278.       }
  279.       
  280.       private function getUniqueItemWrapper(param1:Object, param2:CollectionModification, param3:int, param4:Boolean = false) : Object
  281.       {
  282.          if(Boolean(param2) && (param2.isRemove || param2.modificationType == CollectionModification.REPLACE && !param4))
  283.          {
  284.             if(!itemWrappersByCollectionMod[param2])
  285.             {
  286.                itemWrappersByCollectionMod[param2] = new ItemWrapper(param1);
  287.             }
  288.             return itemWrappersByCollectionMod[param2];
  289.          }
  290.          if(Boolean(param2) && param2.modificationType == CollectionModification.ADD)
  291.          {
  292.             param3 = param2.index;
  293.          }
  294.          if(!itemWrappersByIndex[param3])
  295.          {
  296.             itemWrappersByIndex[param3] = new ItemWrapper(param1);
  297.          }
  298.          return itemWrappersByIndex[param3];
  299.       }
  300.       
  301.       public function enableAutoUpdate() : void
  302.       {
  303.       }
  304.       
  305.       public function set sort(param1:Sort) : void
  306.       {
  307.       }
  308.       
  309.       public function removeItem(param1:ItemWrapper) : void
  310.       {
  311.          var _loc2_:CollectionModification = removedItems[param1] as CollectionModification;
  312.          if(!_loc2_)
  313.          {
  314.             _loc2_ = replacedItems[param1] as CollectionModification;
  315.             if(_loc2_)
  316.             {
  317.                delete replacedItems[param1];
  318.                _loc2_.stopShowingReplacedValue();
  319.                --deltaLength;
  320.                if(_loc2_.modCount == 0)
  321.                {
  322.                   removeModification(_loc2_);
  323.                }
  324.             }
  325.          }
  326.          else if(removeModification(_loc2_))
  327.          {
  328.             delete removedItems[param1];
  329.             --deltaLength;
  330.          }
  331.       }
  332.       
  333.       public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  334.       {
  335.       }
  336.       
  337.       private function integrateRemovedElements(param1:CollectionEvent, param2:int, param3:int) : void
  338.       {
  339.          var _loc9_:CollectionModification = null;
  340.          var _loc10_:CollectionModification = null;
  341.          var _loc4_:int = 0;
  342.          var _loc5_:int = 0;
  343.          var _loc6_:int = 0;
  344.          var _loc7_:int = int(param1.items.length);
  345.          var _loc8_:int = 0;
  346.          while(_loc4_ < deltas.length && _loc5_ < _loc7_)
  347.          {
  348.             _loc9_ = CollectionModification(deltas[_loc4_]);
  349.             _loc10_ = new CollectionModification(param1.location,param1.items[_loc5_],CollectionModification.REMOVE);
  350.             removedItems[getUniqueItemWrapper(param1.items[_loc5_],_loc10_,0)] = _loc10_;
  351.             if(_loc8_ != 0)
  352.             {
  353.                _loc9_.index += _loc8_;
  354.             }
  355.             if(_loc9_.isRemove && _loc9_.index <= _loc10_.index || !_loc9_.isRemove && _loc9_.index < _loc10_.index)
  356.             {
  357.                _loc4_++;
  358.             }
  359.             else
  360.             {
  361.                if(!_loc9_.isRemove && _loc9_.index == _loc10_.index)
  362.                {
  363.                   deltas.splice(_loc4_ + _loc5_,1);
  364.                }
  365.                else
  366.                {
  367.                   deltas.splice(_loc4_ + _loc5_,0,_loc10_);
  368.                   _loc4_++;
  369.                }
  370.                _loc8_--;
  371.                _loc5_++;
  372.             }
  373.          }
  374.          while(_loc4_ < deltas.length)
  375.          {
  376.             _loc9_ = CollectionModification(deltas[_loc4_++]);
  377.             _loc9_.index += _loc8_;
  378.          }
  379.          while(_loc5_ < _loc7_)
  380.          {
  381.             deltas.push(_loc10_ = new CollectionModification(param1.location,param1.items[_loc5_],CollectionModification.REMOVE));
  382.             removedItems[getUniqueItemWrapper(param1.items[_loc5_],_loc10_,0)] = _loc10_;
  383.             _loc5_++;
  384.          }
  385.          deltaLength += param1.items.length - _loc6_;
  386.       }
  387.       
  388.       public function dispatchEvent(param1:Event) : Boolean
  389.       {
  390.          return false;
  391.       }
  392.       
  393.       private function isActive(param1:CollectionModification) : Boolean
  394.       {
  395.          return _showPreserved;
  396.       }
  397.       
  398.       public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
  399.       {
  400.       }
  401.       
  402.       public function refresh() : Boolean
  403.       {
  404.          return false;
  405.       }
  406.       
  407.       public function addItem(param1:ItemWrapper) : void
  408.       {
  409.          var _loc2_:CollectionModification = addedItems[param1] as CollectionModification;
  410.          if(!_loc2_)
  411.          {
  412.             _loc2_ = replacementItems[param1] as CollectionModification;
  413.             if(_loc2_)
  414.             {
  415.                _loc2_.startShowingReplacementValue();
  416.                ++deltaLength;
  417.                if(_loc2_.modCount == 0)
  418.                {
  419.                   removeModification(_loc2_);
  420.                }
  421.             }
  422.          }
  423.          else if(removeModification(_loc2_))
  424.          {
  425.             ++deltaLength;
  426.          }
  427.       }
  428.       
  429.       public function get length() : int
  430.       {
  431.          return list.length + (_showPreserved ? deltaLength : 0);
  432.       }
  433.       
  434.       public function set filterFunction(param1:Function) : void
  435.       {
  436.       }
  437.       
  438.       public function set showPreservedState(param1:Boolean) : void
  439.       {
  440.          _showPreserved = param1;
  441.       }
  442.       
  443.       public function createCursor() : IViewCursor
  444.       {
  445.          var _loc1_:IViewCursor = list.createCursor();
  446.          var _loc2_:Object = _loc1_.current;
  447.          return new ModifiedCollectionViewCursor(this,_loc1_,_loc2_);
  448.       }
  449.       
  450.       private function integrateAddedElements(param1:CollectionEvent, param2:int, param3:int) : void
  451.       {
  452.          var _loc9_:CollectionModification = null;
  453.          var _loc10_:CollectionModification = null;
  454.          var _loc4_:int = 0;
  455.          var _loc5_:int = 0;
  456.          var _loc6_:Boolean = false;
  457.          var _loc7_:int = int(param1.items.length);
  458.          var _loc8_:int = 0;
  459.          while(_loc4_ < deltas.length && _loc5_ < _loc7_)
  460.          {
  461.             _loc9_ = CollectionModification(deltas[_loc4_]);
  462.             _loc10_ = new CollectionModification(param1.location + _loc5_,null,CollectionModification.ADD);
  463.             addedItems[getUniqueItemWrapper(param1.items[_loc5_],_loc10_,0)] = _loc10_;
  464.             if(_loc9_.isRemove && _loc9_.index <= _loc10_.index || !_loc9_.isRemove && _loc9_.index < _loc10_.index)
  465.             {
  466.                _loc4_++;
  467.             }
  468.             else
  469.             {
  470.                deltas.splice(_loc4_ + _loc5_,0,_loc10_);
  471.                _loc8_++;
  472.                _loc5_++;
  473.                _loc4_++;
  474.             }
  475.          }
  476.          while(_loc4_ < deltas.length)
  477.          {
  478.             _loc9_ = CollectionModification(deltas[_loc4_++]);
  479.             _loc9_.index += _loc8_;
  480.          }
  481.          while(_loc5_ < _loc7_)
  482.          {
  483.             deltas.push(_loc10_ = new CollectionModification(param1.location + _loc5_,null,CollectionModification.ADD));
  484.             addedItems[getUniqueItemWrapper(param1.items[_loc5_],_loc10_,0)] = _loc10_;
  485.             _loc5_++;
  486.          }
  487.          deltaLength -= param1.items.length;
  488.       }
  489.       
  490.       public function disableAutoUpdate() : void
  491.       {
  492.       }
  493.       
  494.       public function hasEventListener(param1:String) : Boolean
  495.       {
  496.          return false;
  497.       }
  498.       
  499.       public function get filterFunction() : Function
  500.       {
  501.          return null;
  502.       }
  503.    }
  504. }
  505.  
  506. import flash.events.EventDispatcher;
  507. import mx.collections.errors.CollectionViewError;
  508. import mx.collections.errors.CursorError;
  509. import mx.collections.errors.ItemPendingError;
  510. import mx.core.mx_internal;
  511. import mx.events.FlexEvent;
  512. import mx.resources.IResourceManager;
  513. import mx.resources.ResourceManager;
  514.  
  515. use namespace mx_internal;
  516.  
  517. class ModifiedCollectionViewBookmark extends CursorBookmark
  518. {
  519.    mx_internal var viewRevision:int;
  520.    
  521.    mx_internal var index:int;
  522.    
  523.    mx_internal var internalBookmark:CursorBookmark;
  524.    
  525.    mx_internal var view:ModifiedCollectionView;
  526.    
  527.    mx_internal var internalIndex:int;
  528.    
  529.    public function ModifiedCollectionViewBookmark(param1:Object, param2:ModifiedCollectionView, param3:int, param4:int, param5:CursorBookmark, param6:int)
  530.    {
  531.       super(param1);
  532.       this.mx_internal::view = param2;
  533.       this.mx_internal::viewRevision = param3;
  534.       this.mx_internal::index = param4;
  535.       this.mx_internal::internalBookmark = param5;
  536.       this.mx_internal::internalIndex = param6;
  537.    }
  538.    
  539.    override public function getViewIndex() : int
  540.    {
  541.       return mx_internal::view.mx_internal::getBookmarkIndex(this);
  542.    }
  543. }
  544.  
  545. class ModifiedCollectionViewCursor extends EventDispatcher implements IViewCursor
  546. {
  547.    private static const BEFORE_FIRST_INDEX:int = -1;
  548.    
  549.    private static const AFTER_LAST_INDEX:int = -2;
  550.    
  551.    private var _view:ModifiedCollectionView;
  552.    
  553.    private var resourceManager:IResourceManager;
  554.    
  555.    public var internalIndex:int;
  556.    
  557.    mx_internal var currentIndex:int;
  558.    
  559.    public var internalCursor:IViewCursor;
  560.    
  561.    private var invalid:Boolean;
  562.    
  563.    private var currentValue:Object;
  564.    
  565.    public function ModifiedCollectionViewCursor(param1:ModifiedCollectionView, param2:IViewCursor, param3:Object)
  566.    {
  567.       var view:ModifiedCollectionView = param1;
  568.       var cursor:IViewCursor = param2;
  569.       var current:Object = param3;
  570.       resourceManager = ResourceManager.getInstance();
  571.       super();
  572.       _view = view;
  573.       internalCursor = cursor;
  574.       if(cursor.beforeFirst && !current)
  575.       {
  576.          internalIndex = BEFORE_FIRST_INDEX;
  577.       }
  578.       else if(cursor.afterLast && !current)
  579.       {
  580.          internalIndex = AFTER_LAST_INDEX;
  581.       }
  582.       else
  583.       {
  584.          internalIndex = 0;
  585.       }
  586.       mx_internal::currentIndex = view.length > 0 ? 0 : int(AFTER_LAST_INDEX);
  587.       if(mx_internal::currentIndex == 0)
  588.       {
  589.          try
  590.          {
  591.             setCurrent(current,false);
  592.          }
  593.          catch(e:ItemPendingError)
  594.          {
  595.             mx_internal::currentIndex = BEFORE_FIRST_INDEX;
  596.             setCurrent(null,false);
  597.          }
  598.       }
  599.    }
  600.    
  601.    public function findAny(param1:Object) : Boolean
  602.    {
  603.       return false;
  604.    }
  605.    
  606.    public function findFirst(param1:Object) : Boolean
  607.    {
  608.       return false;
  609.    }
  610.    
  611.    public function seek(param1:CursorBookmark, param2:int = 0, param3:int = 0) : void
  612.    {
  613.       var newCurrent:Object;
  614.       var newIndex:int;
  615.       var message:String = null;
  616.       var mcvBookmark:ModifiedCollectionViewBookmark = null;
  617.       var bookmark:CursorBookmark = param1;
  618.       var offset:int = param2;
  619.       var prefetch:int = param3;
  620.       checkValid();
  621.       if(view.length == 0)
  622.       {
  623.          mx_internal::currentIndex = AFTER_LAST_INDEX;
  624.          setCurrent(null,false);
  625.          return;
  626.       }
  627.       newIndex = int(mx_internal::currentIndex);
  628.       if(bookmark == CursorBookmark.FIRST)
  629.       {
  630.          newIndex = 0;
  631.          internalIndex = 0;
  632.          internalCursor.seek(CursorBookmark.FIRST);
  633.       }
  634.       else if(bookmark == CursorBookmark.LAST)
  635.       {
  636.          newIndex = view.length - 1;
  637.          internalCursor.seek(CursorBookmark.LAST);
  638.       }
  639.       else if(bookmark != CursorBookmark.CURRENT)
  640.       {
  641.          try
  642.          {
  643.             mcvBookmark = bookmark as ModifiedCollectionViewBookmark;
  644.             newIndex = ModifiedCollectionView(view).mx_internal::getBookmarkIndex(bookmark);
  645.             if(!mcvBookmark || newIndex < 0)
  646.             {
  647.                setCurrent(null);
  648.                message = resourceManager.getString("collections","bookmarkInvalid");
  649.                throw new CursorError(message);
  650.             }
  651.             internalIndex = mcvBookmark.mx_internal::internalIndex;
  652.             internalCursor.seek(mcvBookmark.mx_internal::internalBookmark);
  653.          }
  654.          catch(bmError:CollectionViewError)
  655.          {
  656.             message = resourceManager.getString("collections","bookmarkInvalid");
  657.             throw new CursorError(message);
  658.          }
  659.       }
  660.       newIndex += offset;
  661.       newCurrent = null;
  662.       if(newIndex >= view.length)
  663.       {
  664.          mx_internal::currentIndex = AFTER_LAST_INDEX;
  665.       }
  666.       else if(newIndex < 0)
  667.       {
  668.          mx_internal::currentIndex = BEFORE_FIRST_INDEX;
  669.       }
  670.       else
  671.       {
  672.          newCurrent = ModifiedCollectionView(view).mx_internal::getWrappedItemUsingCursor(this,newIndex);
  673.          mx_internal::currentIndex = newIndex;
  674.       }
  675.       setCurrent(newCurrent);
  676.    }
  677.    
  678.    public function insert(param1:Object) : void
  679.    {
  680.    }
  681.    
  682.    [Bindable("cursorUpdate")]
  683.    public function get afterLast() : Boolean
  684.    {
  685.       checkValid();
  686.       return mx_internal::currentIndex == AFTER_LAST_INDEX || view.length == 0;
  687.    }
  688.    
  689.    public function remove() : Object
  690.    {
  691.       return null;
  692.    }
  693.    
  694.    private function checkValid() : void
  695.    {
  696.       var _loc1_:String = null;
  697.       if(invalid)
  698.       {
  699.          _loc1_ = resourceManager.getString("collections","invalidCursor");
  700.          throw new CursorError(_loc1_);
  701.       }
  702.    }
  703.    
  704.    public function get view() : ICollectionView
  705.    {
  706.       checkValid();
  707.       return _view;
  708.    }
  709.    
  710.    public function movePrevious() : Boolean
  711.    {
  712.       if(beforeFirst)
  713.       {
  714.          return false;
  715.       }
  716.       var _loc1_:int = !!afterLast ? int(view.length - 1) : int(mx_internal::currentIndex - 1);
  717.       if(_loc1_ == -1)
  718.       {
  719.          _loc1_ = int(BEFORE_FIRST_INDEX);
  720.          setCurrent(null);
  721.       }
  722.       else
  723.       {
  724.          setCurrent(ModifiedCollectionView(view).mx_internal::getWrappedItemUsingCursor(this,_loc1_));
  725.       }
  726.       mx_internal::currentIndex = _loc1_;
  727.       return !beforeFirst;
  728.    }
  729.    
  730.    public function moveNext() : Boolean
  731.    {
  732.       if(afterLast)
  733.       {
  734.          return false;
  735.       }
  736.       var _loc1_:int = !!beforeFirst ? 0 : int(mx_internal::currentIndex + 1);
  737.       if(_loc1_ >= view.length)
  738.       {
  739.          _loc1_ = int(AFTER_LAST_INDEX);
  740.          setCurrent(null);
  741.       }
  742.       else
  743.       {
  744.          setCurrent(ModifiedCollectionView(view).mx_internal::getWrappedItemUsingCursor(this,_loc1_));
  745.       }
  746.       mx_internal::currentIndex = _loc1_;
  747.       return !afterLast;
  748.    }
  749.    
  750.    public function findLast(param1:Object) : Boolean
  751.    {
  752.       return false;
  753.    }
  754.    
  755.    [Bindable("cursorUpdate")]
  756.    public function get beforeFirst() : Boolean
  757.    {
  758.       checkValid();
  759.       return mx_internal::currentIndex == BEFORE_FIRST_INDEX || view.length == 0;
  760.    }
  761.    
  762.    [Bindable("cursorUpdate")]
  763.    public function get bookmark() : CursorBookmark
  764.    {
  765.       checkValid();
  766.       if(view.length == 0 || Boolean(beforeFirst))
  767.       {
  768.          return CursorBookmark.FIRST;
  769.       }
  770.       if(afterLast)
  771.       {
  772.          return CursorBookmark.LAST;
  773.       }
  774.       return ModifiedCollectionView(view).mx_internal::getBookmark(this);
  775.    }
  776.    
  777.    [Bindable("cursorUpdate")]
  778.    public function get current() : Object
  779.    {
  780.       checkValid();
  781.       return currentValue;
  782.    }
  783.    
  784.    private function setCurrent(param1:Object, param2:Boolean = true) : void
  785.    {
  786.       currentValue = param1;
  787.       if(param2)
  788.       {
  789.          dispatchEvent(new FlexEvent(FlexEvent.CURSOR_UPDATE));
  790.       }
  791.    }
  792. }
  793.  
  794. class CollectionModification
  795. {
  796.    public static const REMOVE:String = "remove";
  797.    
  798.    public static const ADD:String = "add";
  799.    
  800.    public static const REPLACE:String = "replace";
  801.    
  802.    public var showOldReplace:Boolean = true;
  803.    
  804.    private var _modCount:int = 0;
  805.    
  806.    public var showNewReplace:Boolean = false;
  807.    
  808.    public var index:int;
  809.    
  810.    public var modificationType:String = null;
  811.    
  812.    public var item:Object = null;
  813.    
  814.    public function CollectionModification(param1:int, param2:Object, param3:String)
  815.    {
  816.       super();
  817.       this.index = param1;
  818.       this.modificationType = param3;
  819.       if(param3 != CollectionModification.ADD)
  820.       {
  821.          this.item = param2;
  822.       }
  823.       if(param3 == CollectionModification.REMOVE)
  824.       {
  825.          _modCount = 1;
  826.       }
  827.       else if(param3 == CollectionModification.ADD)
  828.       {
  829.          _modCount = -1;
  830.       }
  831.    }
  832.    
  833.    public function startShowingReplacementValue() : void
  834.    {
  835.       showNewReplace = true;
  836.       ++_modCount;
  837.    }
  838.    
  839.    public function get modCount() : int
  840.    {
  841.       return _modCount;
  842.    }
  843.    
  844.    public function get isRemove() : Boolean
  845.    {
  846.       return modificationType == CollectionModification.REMOVE;
  847.    }
  848.    
  849.    public function stopShowingReplacedValue() : void
  850.    {
  851.       showOldReplace = false;
  852.       --_modCount;
  853.    }
  854. }
  855.